home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc™ Source Code / Utilities / ODMathM.a < prev    next >
Encoding:
Text File  |  1996-08-28  |  7.3 KB  |  336 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        ODMathM.a
  3. ;
  4. ;    Contains:    xxx put contents here xxx
  5. ;
  6. ;    Owned by:    Jens Alfke
  7. ;
  8. ;    Copyright:    © 1996 by Apple Computer, Inc., all rights reserved.
  9. ;
  10. ;    Change History (most recent first):
  11. ;
  12. ;         <3>     6/27/96    TJ        Reverted to orignal source.
  13. ;         <2>     5/31/96    JA        CW68K: Moved "_$" headers first to work
  14. ;                                    around CW68K linker bug.
  15. ;
  16. ;    To Do:
  17. ;
  18. ;        This file defines more routines than we need. For now I'm
  19. ;        leaving the extra ones here in case we need 'em later.
  20. ;        These routines are needed (on the Mac) only for 68k.
  21. ;        PowerPC versions are already in the PowerMac Toolbox.
  22. ;    In Progress:
  23. ;        
  24.  
  25.             Machine        MC68020
  26.             MC68881
  27.             Case        On
  28.             Blanks        Off
  29.             
  30. NuRuntime    equ            1
  31.  
  32. negativeInfinity Equ    $80000000
  33. frac1        Equ            $40000000
  34.  
  35.             DataRefs     Relative
  36.             Import        (lastSinCosAngle,lastSine,lastCosine):Data
  37.         
  38. ;    fixed ODFixedMultiply(fixed a, fixed b)
  39. ODFixedMultiply        Func            Export
  40. _$ODFixedMultiply    Func            Export
  41.             move.l        (sp)+,a0
  42.             move.l        (sp),d1
  43.             muls.l         4(sp),d0:d1
  44.             moveq        #0,d2
  45.             add.l        #$00008000,d1
  46.             addx.l        d2,d0
  47.             swap        d1
  48.             swap        d0
  49.             move        d1,d0
  50.             addq.l        #8,sp
  51.             jmp            (a0)
  52.  
  53.  
  54. ;    fixed ODFixedDivide(fixed a, fixed b)
  55. ODFixedDivide        Func            Export
  56. _$ODFixedDivide        Func            Export
  57.             move.l        (sp)+,a0
  58.             move.l        4(sp),d2                get b
  59.             beq.s        @div0
  60.             bpl.s        @1
  61.             neg.l        d2
  62. @1            asr.l        #1,d2
  63.             move.l        (sp),d0                    get a
  64.             bpl.s        @2
  65.             neg.l        d2
  66. @2            swap        d0
  67.             move        d0,d1
  68.             ext.l        d1
  69.             clr.w        d0
  70.             add.l        d2,d0
  71.             bfexts        d2{0:1},d2
  72.             addx.l        d2,d1
  73.             divs.l         4(sp),d1:d0
  74.             bvc.s        @3
  75.             move.l        4(sp),d2                get b
  76. @div0        eor.l        d2,(sp)
  77.             bmi.s        @div1
  78.             move.l        #$7fffffff,d0
  79.             addq.l        #8,sp
  80.             jmp            (a0)
  81. @div1        move.l        #$80000000,d0
  82. @3            addq.l        #8,sp
  83.             jmp            (a0)
  84.  
  85.  
  86. ;    long ODMultiplyDivide(long a, long b, long c)
  87. ODMultiplyDivide        Func            Export
  88. _$ODMultiplyDivide        Func            Export
  89.             move.l        (sp)+,a0
  90.             lea            (sp),a1                    get parameters
  91.             move.l        (a1)+,d0                get a
  92.             move.l        (a1)+,d1                get b
  93.             move.l        (a1),d2                    get c
  94.             beq.s        @div0
  95.             bpl.s            @1
  96.             neg.l            d2
  97. @1            asr.l            #1,d2
  98.             muls.l         d1,d1:d0                compute a*b
  99.             bpl.s            @2
  100.             neg.l            d2
  101. @2            add.l            d2,d0
  102.             bfexts        d2{0:1},d2
  103.             addx.l        d2,d1
  104.             divs.l        (a1),d1:d0            compute a*b/c
  105.             bvc.s        @3
  106.             move.l        (a1),d0
  107. @div0        eor.l            d1,d0
  108.             bmi.s        @div1
  109.             move.l        #$7fffffff,d0
  110.             bra.s        @3
  111. @div1        move.l        #$80000000,d0
  112. @3            lea            12(sp),sp
  113.             jmp            (a0)
  114.  
  115. ;short ODFirstBit(long x)
  116. ODFirstBit    Func            Export
  117. _$ODFirstBit Func            Export
  118.             move.l            (sp)+,a0                get return address
  119.             move.l            (sp),d0                    get x
  120.             bfffo            d0{0:0},d1
  121.             moveq            #31,d0
  122.             sub.w            d1,d0
  123.             addq.l            #4,sp
  124.             jmp                (a0)
  125.  
  126. ;    fract ODFractMultiply(fract a, fract b)
  127. ODFractMultiply        Func            Export
  128. _$ODFractMultiply    Func            Export
  129.             move.l        (sp)+,a0
  130.             move.l        (sp),d1
  131.             muls.l         4(sp),d0:d1
  132.             moveq        #0,d2
  133.             add.l            #$20000000,d1
  134.             addx.l        d2,d0
  135.             lsl.l            #2,d0                     2.30 (toss overflow bits)    
  136.             rol.l            #2,d1
  137.             and            #3,d1                     get high 2 bits of low long
  138.             or            d1,d0
  139.             addq.l        #8,sp
  140.             jmp            (a0)
  141.  
  142.  
  143. ;    fixed ODFractDivide(fract a, fract b)
  144. ODFractDivide        Func        Export
  145. _$ODFractDivide        Func        Export
  146.             move.l        (sp)+,a0
  147.             move.l        4(sp),d2                get b
  148.             beq.s        @div0
  149.             bpl.s            @1
  150.             neg.l            d2
  151. @1            move.l        (sp),d1                    get a
  152.             bpl.s            @2
  153.             neg.l            d2
  154. @2            clr.l            d0
  155.             asr.l            #1,d1
  156.             roxr.l        #1,d0
  157.             add.l            d2,d0
  158.             bfexts        d2{0:1},d2
  159.             addx.l        d2,d1
  160.             asr.l            #1,d1
  161.             roxr.l        #1,d0
  162.             divs.l         4(sp),d1:d0
  163.             bvc.s        @3
  164.             move.l        4(sp),d2                get b
  165. @div0        eor.l            d2,(sp)
  166.             bmi.s        @div1
  167.             move.l        #$7fffffff,d0
  168.             addq.l        #8,sp
  169.             jmp            (a0)
  170. @div1        move.l        #$80000000,d0
  171. @3            addq.l        #8,sp
  172.             jmp            (a0)
  173.  
  174.  
  175. ;    fract ODFractSinCos(fixed radians, fract *b)
  176. ;
  177. ; ODFractSinCos requires the NuRuntime Prolog
  178. ; because it uses xxx(A5) relative references to data constants and so must
  179. ;"switch" A5
  180. ODFractSinCos    Func            Export
  181.     IF    NuRuntime THEN
  182.             MOVE.L    (A1),A5
  183.     ENDIF
  184. _$ODFractSinCos    Func            Export
  185.             move.l        (sp)+,a0
  186.             move.l        (sp),d0                    get degree
  187.             cmp.l        lastSinCosAngle(A5),d0
  188.             beq.s        @useOld
  189.             move.l        d0,lastSinCosAngle(A5)
  190. ;
  191. ; (original code expected input in degrees; remove this)
  192. ;            fmovecr.x    #0,fp0                get π
  193. ;            fdiv.w        #180,fp0                compute 1 degree in radians
  194. ;            fmul.l        d0,fp0                    multiply by angle
  195. ; here's what the above 3 instructions became:
  196.             fmove.l        d0,fp0                    angle already in radians
  197. ; (end fix)
  198.             fscale.w    #-16,fp0                bias by 16
  199.             fsincos.x    fp0,fp1:fp0
  200.             fscale.w    #30,fp0                bias by 30
  201.             fmove.l        fp0,d0    
  202.             fscale.w    #30,fp1                bias by 30
  203.             move.l        4(sp),a1
  204.             fmove.l        fp1,(a1)
  205.             move.l        d0,lastSine(A5)
  206.             move.l        (a1),lastCosine(A5)
  207.             addq.l        #8,sp
  208.             jmp            (a0)
  209. @useOld
  210.             move.l        4(sp),a1                    get b
  211.             move.l        lastSine(A5),d0
  212.             move.l        lastCosine(A5),(a1)
  213.             addq.l        #8,sp
  214.             jmp            (a0)
  215.  
  216.     
  217. ; wide *ODWideMultiply(long src1, long src2, wide *dst)
  218. ODWideMultiply        Func            Export
  219. _$ODWideMultiply    Func            Export
  220.             move.l        4(sp),d0
  221.             muls.l        8(sp), d1:d0
  222.             move.l        12(sp),a0
  223.             move.l        d1,(a0)+
  224.             move.l        d0,(a0)
  225.             move.l        12(sp),d0
  226.             rtd            #12
  227.  
  228.  
  229. ; long ODWideDivide(wide *num, long denom, long *rem)
  230. ODWideDivide    Func            Export
  231. _$ODWideDivide    Func            Export
  232.             link            a6,#-2
  233.             moveq        #-1,d0
  234.             cmp.l        16(a6),d0                if (rem == (void *)-1)
  235.             seq            -1(a6)                    set check
  236.             bne.s        @noCheck
  237.             clr.l            16(a6)                    rem = 0
  238. @noCheck
  239.             move.l        8(a6),a0                get num
  240.             move.l        (a0)+,d1
  241.             move.l        (a0),d0
  242.             move.l        12(a6),d2                get denom
  243.             beq.s        @div0
  244.             bpl.s            @1
  245.             neg.l            d2
  246. @1            tst.l            16(a6)                    check rem
  247.             bne.s        @3
  248.             lsr.l            #1,d2
  249.             tst.l            d1
  250.             bpl.s            @2
  251.             neg.l            d2
  252. @2            add.l            d2,d0
  253.             bfexts        d2{0:1},d2
  254.             addx.l        d2,d1
  255. @3            divs.l        12(a6),d1:d0
  256.             bvc.s        @ok
  257.             move.l        12(a6),d2
  258. @div0        tst.b            -1(a6)                    check check
  259.             bne.s        @div1
  260.             eor.l            d1,d2
  261.             bmi.s        @div1
  262.             move.l        #$7FFFFFFF,d0
  263.             bra.s        @div2
  264. @div1        move.l        #$80000000,d0
  265. @div2        move.l        #$80000000,d1
  266. @ok            move.l        16(a6),d2                get rem
  267.             beq.s        @done
  268.             move.l        d2,a0
  269.             move.l        d1,(a0)
  270. @done        unlk        a6
  271.             rtd            #12
  272.  
  273. ; long ODWideSquareRoot(wide *src)
  274. ODWideSquareRoot    Func            Export
  275. _$ODWideSquareRoot    Func            Export
  276.             move.l        (sp)+,a0
  277.             move.l        #$80000000,d1
  278.             fmove.l        d1,fp1
  279.             move.l        (sp),a1                        Get src
  280.             move.l        (a1)+,d0                    Get hi long
  281.             add.l            d1,d0                        Offset for sign
  282.             fmove.l        d0,fp0                        Move to FP0
  283.             fsub.x        fp1,fp0                        Compensate for offset
  284.             fscale.w    #32,fp0                    Shift by 32
  285.             move.l        (a1),d0                        Get lo long
  286.             add.l            d1,d0                        Offset for sign
  287.             fadd.l        d0,fp0                        Add to FP0
  288.             fsub.x        fp1,fp0                        Compensate for offset
  289.             fsqrt.x        fp0                            The whole point
  290.             fadd.x        fp1,fp0                        Offset for sign
  291.             fmove.l        fp0,d0                        Pass result to D0
  292.             sub.l            d1,d0                        Compensate for offset
  293.             addq.l        #4,sp
  294.             jmp            (a0)
  295.  
  296. ;fract ODFractCubeRoot(fract x)
  297. ODFractCubeRoot        Func        Export
  298. _$ODFractCubeRoot    Func        Export
  299.             move.l        (sp)+,a0            ;get return address
  300.             move.l        (sp),d0                ;get x
  301.             beq.s        @2
  302.             smi            d1                    ;save the sign
  303.             bpl.s            @1
  304.             neg.l            d0
  305. @1            fmove.l        d0,fp0
  306.             flogn            fp0                    ;take its logarithm
  307.             fdiv.w        #3,fp0
  308.             fetox        fp0                    ;exponentiate
  309.             fscale.w    #20,fp0            ;scale for fract
  310.             fmove.l        fp0,d0
  311.             tst.b            d1                    ;check the sign
  312.             beq.s        @2
  313.             neg.l            d0
  314. @2            addq.l        #4,sp
  315.             jmp         (a0)
  316.  
  317.  
  318.     IF NuRuntime THEN
  319.     
  320.         XVector    ODFixedMultiply:0
  321.         XVector    ODFixedDivide:0
  322.         XVector    ODMultiplyDivide:0
  323.         XVector    ODFirstBit:0
  324.         XVector    ODFractMultiply:0
  325.         XVector    ODFractDivide:0
  326.  
  327.         XVector    ODFractSinCos:0
  328.  
  329.          XVector    ODWideMultiply:0
  330.         XVector    ODWideDivide:0
  331.         XVector    ODWideSquareRoot:0
  332.         XVector    ODFractCubeRoot:0
  333.  
  334.     ENDIF
  335.  
  336.             End